// pages/create/create.js
const aiApi = require('../../api/aiApi');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    prompt: '',
    negativePrompt: '',
    loading: false,
    generatedImage: '',
    imageTaskId: '',
    taskStatus: '',
    progress: 0,
    selectedStyle: 'realistic',
    selectedStyleName: '写实',
    imageSize: '1024*1024',
    pollingTimer: null,
    estimatedTimeLeft: 0, // 预计剩余时间（秒）
    progressAnimInterval: null, // 进度条自动递增的定时器
    canCancel: false, // 是否可以取消生成
    userTips: [], // 给用户的提示信息
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 初始化
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    this.clearPolling();
    this.clearProgressAnim();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    if (this.data.generatedImage) {
      return {
        title: `AI创作：${this.data.prompt.slice(0, 20)}...`,
        imageUrl: this.data.generatedImage,
        path: `/pages/detail/detail?id=${this.data.imageTaskId}`
      }
    }
    return {
      title: '一键生成精美AI图像',
      path: '/pages/create/create'
    }
  },

  // 输入提示词 - 适配TDesign
  onInputPrompt: function(e) {
    this.setData({
      prompt: e.detail.value
    });
  },

  // 输入反向提示词
  onInputNegativePrompt: function(e) {
    this.setData({
      negativePrompt: e.detail.value
    });
  },

  // 清空提示词
  clearPrompt: function() {
    this.setData({
      prompt: ''
    });
  },

  // 使用随机提示词
  useRandomPrompt: function() {
    const randomPrompts = [
      '星空下的古城堡，满天繁星',
      '未来城市的霓虹灯街道，充满科技感',
      '山间湖泊旁的木屋，秋天的景色',
      '梦幻森林中的精灵和魔法生物',
      '海底世界的珊瑚礁和热带鱼'
    ];
    
    const randomIndex = Math.floor(Math.random() * randomPrompts.length);
    this.setData({
      prompt: randomPrompts[randomIndex]
    });
  },

  // 清除轮询定时器
  clearPolling: function() {
    if (this.data.pollingTimer) {
      clearTimeout(this.data.pollingTimer);
      this.setData({
        pollingTimer: null
      });
    }
  },

  // 清除进度条自动递增
  clearProgressAnim: function() {
    if (this.data.progressAnimInterval) {
      clearInterval(this.data.progressAnimInterval);
      this.setData({
        progressAnimInterval: null
      });
    }
  },

  // 启动进度条动画
  startProgressAnimation: function() {
    // 清除之前的动画
    this.clearProgressAnim();
    
    // 初始化进度数据
    this.setData({
      progress: 10,
      estimatedTimeLeft: 60, // 预计60秒完成
      userTips: [
        '正在创建任务，请稍等...',
        '复杂图像可能需要较长时间，请耐心等待',
        '您可以向下滑动查看生成提示'
      ]
    });
    
    // 设置进度条自动递增
    const interval = setInterval(() => {
      const currentProgress = this.data.progress;
      const currentTime = this.data.estimatedTimeLeft;
      
      // 更新倒计时
      if (currentTime > 0) {
        this.setData({
          estimatedTimeLeft: currentTime - 1
        });
      }
      
      // 仅在不超过90%的情况下自动增加进度
      if (currentProgress < 90) {
        let increment = 0.5; // 默认每次增加0.5%
        
        // 根据当前进度调整增量
        if (currentProgress < 30) {
          increment = 1; // 前期快速增加
        } else if (currentProgress >= 70) {
          increment = 0.1; // 后期缓慢增加
        }
        
        this.setData({
          progress: currentProgress + increment
        });
      }
      
      // 每15秒更新一条提示
      if (currentTime % 15 === 0 && currentTime > 0) {
        const tips = [
          '生成高质量图像需要更多时间...',
          '复杂描述的图像需要更多处理时间',
          '服务器正在努力创作您的图像',
          '您的图像正在创作中，即将完成',
          '正在处理图像细节...'
        ];
        const randomTip = tips[Math.floor(Math.random() * tips.length)];
        
        // 添加随机提示
        const userTips = this.data.userTips;
        if (userTips.length > 3) {
          userTips.shift(); // 移除最旧的提示
        }
        userTips.push(randomTip);
        
        this.setData({
          userTips
        });
      }
    }, 1000);
    
    this.setData({
      progressAnimInterval: interval,
      canCancel: true // 启动进度条后允许取消
    });
  },

  // 生成图像
  generateImage: function() {
    if (!this.data.prompt.trim()) {
      wx.showToast({
        title: '请输入提示词',
        icon: 'none'
      });
      return;
    }
    
    this.setData({ 
      loading: true,
      taskStatus: '准备中...',
      generatedImage: ''
    });
    
    // 启动进度条动画
    this.startProgressAnimation();
    
    // 构建请求参数
    const options = {
      size: this.data.imageSize,
      n: 1,
      style: this.data.selectedStyle
    };
    
    aiApi.generateImage(this.data.prompt, this.data.negativePrompt, options)
      .then(res => {
        console.log('生成任务创建成功:', res);
        
        // 保存任务ID并更新状态
        this.setData({
          imageTaskId: res.taskId,
          taskStatus: res.status || 'PENDING',
          progress: Math.max(this.data.progress, 30) // 确保进度至少为30%
        });
        
        // 将用户提示更新为API返回的状态
        const userTips = this.data.userTips;
        userTips.push(`任务创建成功，ID: ${res.taskId.slice(0, 8)}...`);
        if (userTips.length > 3) {
          userTips.shift();
        }
        
        this.setData({
          userTips
        });
        
        // 开始轮询任务状态
        this.pollTaskStatus();
      })
      .catch(err => {
        console.error('创建图像生成任务失败', err);
        this.clearProgressAnim(); // 停止进度条动画
        
        this.setData({ 
          loading: false,
          taskStatus: '生成失败',
          canCancel: false
        });
        
        wx.showToast({
          title: err.message || '创建任务失败，请重试',
          icon: 'none'
        });
      });
  },

  // 轮询任务状态
  pollTaskStatus: function() {
    if (!this.data.imageTaskId) return;
    
    // 更新状态文本
    this.updateStatusText();
    
    const poll = () => {
      aiApi.getImageResult(this.data.imageTaskId)
        .then(res => {
          console.log('任务状态:', res);
          
          if (res && res.data) {
            const status = res.data.status;
            this.setData({
              taskStatus: status
            });
            
            // 更新用户提示
            const userTips = this.data.userTips;
            let statusMessage = this.getDetailedStatusMessage(status);
            
            // 避免重复的状态消息
            if (!userTips.includes(statusMessage)) {
              if (userTips.length > 3) {
                userTips.shift();
              }
              userTips.push(statusMessage);
              this.setData({ userTips });
            }
            
            if (status === 'SUCCEEDED') {
              // 任务成功完成
              this.handleTaskSuccess(res.data);
            } else if (status === 'FAILED' || status === 'SUSPENDED') {
              // 任务失败
              this.handleTaskFailed(res.message || '图像生成失败');
            } else {
              // 任务仍在进行中，继续轮询
              // 更新进度，但确保不会后退
              const newProgress = Math.max(
                this.data.progress,
                status === 'PENDING' ? 40 : 60
              );
              
              this.setData({
                progress: newProgress
              });
              
              // 继续轮询，RUNNING状态下缩短轮询间隔
              const pollInterval = status === 'RUNNING' ? 1500 : 2000;
              const timer = setTimeout(poll, pollInterval);
              this.setData({
                pollingTimer: timer
              });
            }
          }
        })
        .catch(err => {
          console.error('查询任务状态失败', err);
          // 如果是API调用失败，才认为是真正的错误
          if (err && !err.data) {
            this.handleTaskFailed(err.message || '查询任务状态失败');
          } else {
            // 继续轮询
            const timer = setTimeout(poll, 2000);
            this.setData({
              pollingTimer: timer
            });
          }
        });
    };
    
    // 开始轮询
    poll();
  },

  // 获取详细状态消息
  getDetailedStatusMessage: function(status) {
    switch(status) {
      case 'PENDING':
        return '您的任务正在排队等待处理...';
      case 'RUNNING':
        return '正在创作您的图像，即将完成...';
      case 'SUCCEEDED':
        return '图像创作成功！';
      case 'FAILED':
        return '图像创作失败，请尝试重新生成';
      case 'SUSPENDED':
        return '任务已暂停，请尝试重新生成';
      default:
        return '正在处理您的请求...';
    }
  },

  // 更新状态文本
  updateStatusText: function() {
    let statusText = '准备中...';
    
    switch(this.data.taskStatus) {
      case 'PENDING':
        statusText = '任务排队中...';
        break;
      case 'RUNNING':
        statusText = '正在生成图像...';
        break;
      case 'SUCCEEDED':
        statusText = '生成成功';
        break;
      case 'FAILED':
        statusText = '生成失败';
        break;
      case 'SUSPENDED':
        statusText = '任务已挂起';
        break;
    }
    
    this.setData({
      taskStatus: statusText
    });
  },

  // 处理任务成功
  handleTaskSuccess: function(taskData) {
    // 清除轮询和进度条动画
    this.clearPolling();
    this.clearProgressAnim();
    
    try {
      // 从结果中获取图片URL
      const imageUrl = taskData.result.output.results[0].url;
      
      this.setData({
        generatedImage: imageUrl,
        loading: false,
        progress: 100,
        taskStatus: '生成成功',
        canCancel: false
      });
      
      // 将生成的图像信息保存到全局
      getApp().globalData.currentImage = {
        imageUrl: imageUrl,
        prompt: this.data.prompt,
        negativePrompt: this.data.negativePrompt,
        taskId: this.data.imageTaskId,
        size: this.data.imageSize,
        style: this.data.selectedStyle,
        styleName: this.data.selectedStyleName,
        createTime: new Date().toLocaleString()
      };
    } catch (err) {
      console.error('解析图像结果失败', err);
      this.handleTaskFailed('获取图像URL失败');
    }
  },

  // 处理任务失败
  handleTaskFailed: function(message) {
    // 清除轮询和进度条动画
    this.clearPolling();
    this.clearProgressAnim();
    
    this.setData({
      loading: false,
      taskStatus: '生成失败',
      canCancel: false
    });
    
    wx.showToast({
      title: message,
      icon: 'none'
    });
  },

  // 取消生成
  cancelGeneration: function() {
    wx.showModal({
      title: '取消生成',
      content: '确定要取消当前图像生成任务吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除轮询和进度条动画
          this.clearPolling();
          this.clearProgressAnim();
          
          this.setData({
            loading: false,
            taskStatus: '',
            progress: 0,
            canCancel: false,
            userTips: []
          });
          
          wx.showToast({
            title: '已取消生成',
            icon: 'none'
          });
        }
      }
    });
  },

  // 预览图片
  previewImage: function() {
    if (!this.data.generatedImage) return;
    
    wx.previewImage({
      urls: [this.data.generatedImage],
      current: this.data.generatedImage,
      showmenu: true
    });
  },

  // 重新生成
  regenerateImage: function() {
    if (this.data.loading) return;
    
    this.setData({ 
      loading: true,
      progress: 10,
      taskStatus: '准备中...',
      generatedImage: ''
    });
    
    // 启动进度条动画
    this.startProgressAnimation();
    
    // 构建请求参数
    const options = {
      size: this.data.imageSize,
      n: 1,
      style: this.data.selectedStyle
    };
    
    // 可以传入当前任务ID进行重新生成
    aiApi.regenerateImage(
      this.data.imageTaskId, 
      this.data.prompt, 
      this.data.negativePrompt,
      options
    )
      .then(res => {
        console.log('重新生成任务创建成功:', res);
        
        // 保存新的任务ID并开始轮询结果
        this.setData({
          imageTaskId: res.taskId,
          taskStatus: res.status || 'PENDING',
          progress: Math.max(this.data.progress, 30)
        });
        
        // 开始轮询任务状态
        this.pollTaskStatus();
      })
      .catch(err => {
        console.error('创建重新生成任务失败', err);
        this.clearProgressAnim(); // 停止进度条动画
        
        this.setData({ 
          loading: false,
          taskStatus: '生成失败',
          canCancel: false
        });
        
        wx.showToast({
          title: err.message || '重新生成失败，请重试',
          icon: 'none'
        });
      });
  },

  // 保存图片到本地
  saveToLocal: function() {
    if (!this.data.generatedImage) return;
    
    wx.showLoading({
      title: '保存中...',
    });
    
    wx.downloadFile({
      url: this.data.generatedImage,
      success: (res) => {
        if (res.statusCode === 200) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              wx.hideLoading();
              wx.showToast({
                title: '保存成功',
                icon: 'success'
              });
            },
            fail: (err) => {
              wx.hideLoading();
              wx.showToast({
                title: '保存失败',
                icon: 'none'
              });
              console.error('保存到相册失败', err);
            }
          });
        } else {
          wx.hideLoading();
          wx.showToast({
            title: '下载失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        wx.showToast({
          title: '下载失败',
          icon: 'none'
        });
        console.error('下载图片失败', err);
      }
    });
  },

  // 前往发布页面
  goToPublish: function() {
    if (!this.data.generatedImage) return;
    
    wx.navigateTo({
      url: '/pages/publish/publish'
    });
  },

  // 重新开始，清空当前结果
  startOver: function() {
    wx.showModal({
      title: '确认重新开始',
      content: '当前生成的图像将不会保存，是否继续？',
      confirmText: '继续',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 重置页面状态
          this.setData({
            generatedImage: '',
            imageTaskId: '',
            progress: 0,
            loading: false,
            taskStatus: '',
            userTips: []
          });
        }
      }
    });
  }
})